// src/store/card.ts
import { defineStore } from 'pinia'
import { ref, reactive } from 'vue'
import type { baseCard, activityCard, missionCard } from '@/types/card'
import { activityCardApi, missionCardApi } from '@/api/card'
import { useTaskListStore } from '@/store/taskList'

export const useCardStore = defineStore('card', () => {
  // 基础卡片状态
  const showBaseCard = ref(false)
  const baseCardPosition = reactive({ x: 0, y: 0 })
  const currentSelectedDate = ref<Date>(new Date())
  
  // 存储的卡片数据
  const activityCards = ref<activityCard[]>([])
  const missionCards = ref<missionCard[]>([])
  
  // 临时按钮状态（用于未保存的卡片）
  const tempButtonDate = ref<Date | null>(null)
  const tempCardTitle = ref<string>('') // 临时卡片的标题
  
  // 新增：详情卡片状态
  const showDetailCard = ref(false)
  const currentDetailCard = ref<activityCard | missionCard | null>(null)
  const detailCardPosition = reactive({ x: 0, y: 0 })

  const normalizeDateOnly = (date: Date) => new Date(date.getFullYear(), date.getMonth(), date.getDate())

  // 打开基础卡片
  const openBaseCard = (date: Date, position: { x: number; y: number }, forceNew: boolean = false, specificCard?: activityCard | missionCard) => {
    // 如果指定了特定卡片，直接打开BaseCard（编辑模式）
    // 注意：调用方需要确保BaseCard组件接收到editCardData prop
    if (specificCard) {
      currentSelectedDate.value = date
      baseCardPosition.x = position.x
      baseCardPosition.y = position.y
      showBaseCard.value = true
      // 不设置临时按钮日期，因为这是编辑已有卡片
      tempButtonDate.value = null
      return
    }
    
    // 如果不强制新建，检查该日期是否已有保存的卡片
    if (!forceNew) {
      const existingCard = getCardForDate(date)
      if (existingCard) {
        // 如果有保存的卡片，直接打开详情卡片
        openDetailCard(existingCard, position)
        return
      }
    }
    
    currentSelectedDate.value = date
    baseCardPosition.x = position.x
    baseCardPosition.y = position.y
    showBaseCard.value = true
    // 设置临时按钮日期和标题
    tempButtonDate.value = date
    tempCardTitle.value = '' // 重置临时标题
  }

  // 新增：打开详情卡片
  const openDetailCard = (card: activityCard | missionCard, position: { x: number; y: number }) => {
    currentDetailCard.value = card
    detailCardPosition.x = position.x
    detailCardPosition.y = position.y
    showDetailCard.value = true
  }

  // 新增：关闭详情卡片
  const closeDetailCard = () => {
    showDetailCard.value = false
    currentDetailCard.value = null
  }

  // 关闭基础卡片（不保存时清除临时按钮）
  const closeBaseCard = (saveData: baseCard | null = null) => {
    showBaseCard.value = false
    // 如果没有保存数据，清除临时按钮
    if (!saveData) {
      tempButtonDate.value = null
      tempCardTitle.value = ''
    }
  }
  
  // 更新临时卡片标题
  const updateTempCardTitle = (title: string) => {
    tempCardTitle.value = title
  }

  const updateTempButtonDate = (date: Date | null) => {
    if (date) {
      tempButtonDate.value = normalizeDateOnly(date)
    } else {
      tempButtonDate.value = null
    }
  }

  // 更新卡片位置
  const updateBaseCardPosition = (position: { x: number; y: number }) => {
    baseCardPosition.x = position.x
    baseCardPosition.y = position.y
  }

  // 调整卡片位置（边界检查）
  const adjustedBaseCardPosition = () => {
    const cardWidth = 360  // 更新为新的宽度
    const cardHeight = 420 // 更新为新的高度
    const margin = 10
    
    let adjustedX = baseCardPosition.x
    let adjustedY = baseCardPosition.y
    
    if (adjustedX + cardWidth > window.innerWidth) {
      adjustedX = window.innerWidth - cardWidth - margin
    }
    if (adjustedX < margin) {
      adjustedX = margin
    }
    if (adjustedY + cardHeight > window.innerHeight) {
      adjustedY = window.innerHeight - cardHeight - margin
    }
    if (adjustedY < margin) {
      adjustedY = margin
    }
    
    return { x: adjustedX, y: adjustedY }
  }

  // 新增：调整详情卡片位置
  const adjustedDetailCardPosition = () => {
    const cardWidth = 320
    const cardHeight = 400
    const margin = 10
    
    let adjustedX = detailCardPosition.x
    let adjustedY = detailCardPosition.y
    
    if (adjustedX + cardWidth > window.innerWidth) {
      adjustedX = window.innerWidth - cardWidth - margin
    }
    if (adjustedX < margin) {
      adjustedX = margin
    }
    if (adjustedY + cardHeight > window.innerHeight) {
      adjustedY = window.innerHeight - cardHeight - margin
    }
    if (adjustedY < margin) {
      adjustedY = margin
    }
    
    return { x: adjustedX, y: adjustedY }
  }

  // 保存卡片数据 - 支持新建和更新
  const saveACard = async (cardData: activityCard) => {
    try {
      let savedCard: activityCard
      // 检查是否已存在（编辑模式）
      const existingIndex = activityCards.value.findIndex(card => card.id === cardData.id)
      if (existingIndex !== -1) {
        // 更新已有卡片
        const { id, createdAt, ...updateData } = cardData
        savedCard = await activityCardApi.update(id, updateData) as activityCard
        if (savedCard) {
          activityCards.value[existingIndex] = savedCard
        }
      } else {
        // 新建卡片
        const { id, createdAt, updatedAt, ...createData } = cardData
        savedCard = await activityCardApi.create(createData)
        activityCards.value.push(savedCard)
      }
      // 保存后清除临时按钮状态
      tempButtonDate.value = null
      tempCardTitle.value = ''
      return savedCard
    } catch (error) {
      console.error('保存活动卡片失败:', error)
      throw error
    }
  }
  
  // 同步标志，避免循环同步
  const isSyncingToTaskList = ref(false)
  
  const saveMCard = async (cardData: missionCard, skipTaskListSync: boolean = false) => {
    try {
      const originContext = cardData.originContext ?? 'grid'
      cardData.originContext = originContext

      let savedCard: missionCard
      const isNew = !missionCards.value.find(card => card.id === cardData.id)
      
      // 检查是否已存在（编辑模式）
      const existingIndex = missionCards.value.findIndex(card => card.id === cardData.id)
      if (existingIndex !== -1) {
        // 更新已有卡片
        const { id, createdAt, ...updateData } = cardData
        savedCard = await missionCardApi.update(id, updateData) as missionCard
        if (savedCard) {
          savedCard.originContext = originContext
          missionCards.value[existingIndex] = savedCard
        }
      } else {
        // 新建卡片
        const { id, createdAt, updatedAt, ...createData } = cardData
        savedCard = await missionCardApi.create(createData)
        savedCard.originContext = originContext
        missionCards.value.push(savedCard)
      }
      
      // 同步到任务列表（如果未跳过同步且不在同步中）
      if (!skipTaskListSync && !isSyncingToTaskList.value) {
        try {
          isSyncingToTaskList.value = true
          const taskListStore = useTaskListStore()
          
          // 确保任务列表已初始化
          if (taskListStore.taskLists.length === 0) {
            await taskListStore.init()
          }
          
          // 将日期转换为字符串格式
          const taskDate = formatDateForTask(savedCard.date)
          
          // 统一处理空标题：如果标题为空或"（无标题）"，统一使用"新任务"
          const normalizedCardTitle = savedCard.title && savedCard.title.trim() && savedCard.title !== '（无标题）' 
            ? savedCard.title.trim() 
            : '新任务'
          
          // 如果任务卡片有taskListId，同步到对应的任务列表
          if (savedCard.taskListId) {
            const targetTaskList = taskListStore.taskLists.find(list => list.id === savedCard.taskListId)
            if (!targetTaskList) {
              console.warn('未找到对应的任务列表:', savedCard.taskListId)
              return savedCard
            }
            
            // 优先通过taskListId匹配任务
            // 首先尝试通过日期和标题匹配（最常用的情况）
            let existingTask = targetTaskList.tasks.find(task => {
              const normalizedTaskTitle = task.title && task.title.trim() ? task.title.trim() : '新任务'
              return task.date === taskDate && normalizedTaskTitle === normalizedCardTitle
            })
            
            // 如果找不到，尝试通过其他方式匹配（例如通过任务的其他特征）
            // 这里可以扩展匹配逻辑
            
            if (existingTask) {
              // 更新任务
              console.log('更新任务列表中的任务:', existingTask.id, normalizedCardTitle, '列表:', targetTaskList.name)
              await taskListStore.updateTask(targetTaskList.id, existingTask.id, {
                title: normalizedCardTitle,
                description: savedCard.remark || '',
                date: taskDate,
                completed: savedCard.isFinished || false
              }, true) // 跳过日历同步
            } else {
              // 添加新任务
              console.log('添加任务到任务列表:', normalizedCardTitle, taskDate, '列表:', targetTaskList.name)
              await taskListStore.addTask(targetTaskList.id, {
                title: normalizedCardTitle,
                description: savedCard.remark || '',
                date: taskDate,
                showDateAsText: false,
                completed: savedCard.isFinished || false,
                editingTitle: false,
                editingDesc: false,
                starred: false
              }, true) // 跳过日历同步
            }
          } else {
            // 兼容旧数据：如果没有taskListId，同步到"我的任务"列表
            const myTaskList = taskListStore.taskLists.find(list => list.name === '我的任务')
            if (!myTaskList) {
              console.warn('未找到"我的任务"列表，无法同步')
              return savedCard
            }
            
            // 查找是否已存在对应的任务（通过日期和标题匹配）
            const existingTask = myTaskList.tasks.find(task => {
              const normalizedTaskTitle = task.title && task.title.trim() ? task.title.trim() : '新任务'
              return task.date === taskDate && normalizedTaskTitle === normalizedCardTitle
            })
            
            if (existingTask) {
              // 更新任务
              console.log('更新任务列表中的任务:', existingTask.id, normalizedCardTitle)
              await taskListStore.updateTask(myTaskList.id, existingTask.id, {
                title: normalizedCardTitle,
                description: savedCard.remark || '',
                date: taskDate,
                completed: savedCard.isFinished || false
              }, true) // 跳过日历同步
            } else {
              // 添加新任务
              console.log('添加任务到任务列表:', normalizedCardTitle, taskDate)
              await taskListStore.addTask(myTaskList.id, {
                title: normalizedCardTitle,
                description: savedCard.remark || '',
                date: taskDate,
                showDateAsText: false,
                completed: savedCard.isFinished || false,
                editingTitle: false,
                editingDesc: false,
                starred: false
              }, true) // 跳过日历同步
            }
          }
        } catch (syncError) {
          console.error('同步到任务列表失败:', syncError)
          // 不同步失败不影响主流程
        } finally {
          isSyncingToTaskList.value = false
        }
      }
      
      // 保存后清除临时按钮状态
      tempButtonDate.value = null
      tempCardTitle.value = ''
      return savedCard
    } catch (error) {
      console.error('保存任务卡片失败:', error)
      throw error
    }
  }
  
  // 格式化日期为任务列表使用的格式
  const formatDateForTask = (date: Date): string => {
    const today = new Date()
    today.setHours(0, 0, 0, 0)
    const tomorrow = new Date(today)
    tomorrow.setDate(tomorrow.getDate() + 1)
    const taskDate = new Date(date)
    taskDate.setHours(0, 0, 0, 0)
    
    if (taskDate.getTime() === today.getTime()) {
      return 'today'
    } else if (taskDate.getTime() === tomorrow.getTime()) {
      return 'tomorrow'
    } else {
      // 返回日期字符串 YYYY-MM-DD
      const year = taskDate.getFullYear()
      const month = String(taskDate.getMonth() + 1).padStart(2, '0')
      const day = String(taskDate.getDate()).padStart(2, '0')
      return `${year}-${month}-${day}`
    }
  }

  // 删除活动卡片 - 更新为使用API
  const deleteACard = async (id: string) => {
    try {
      const success = await activityCardApi.delete(id)
      if (success) {
        const index = activityCards.value.findIndex(card => card.id === id)
        if (index !== -1) {
          activityCards.value.splice(index, 1)
        }
      }
    } catch (error) {
      console.error('删除活动卡片失败:', error)
      throw error
    }
  }

  // 删除任务卡片 - 更新为使用API
  const deleteMCard = async (id: string, skipTaskListSync: boolean = false) => {
    try {
      // 先获取要删除的卡片信息，用于同步删除任务列表中的任务
      const cardToDelete = missionCards.value.find(card => card.id === id)
      
      const success = await missionCardApi.delete(id)
      if (success) {
        const index = missionCards.value.findIndex(card => card.id === id)
        if (index !== -1) {
          missionCards.value.splice(index, 1)
        }
        
        // 同步删除任务列表中的任务（如果未跳过同步且不在同步中）
        if (cardToDelete && !skipTaskListSync && !isSyncingToTaskList.value) {
          try {
            isSyncingToTaskList.value = true
            const taskListStore = useTaskListStore()
            
            // 确保任务列表已初始化
            if (taskListStore.taskLists.length === 0) {
              await taskListStore.init()
            }
            
            const taskDate = formatDateForTask(cardToDelete.date)
            // 统一处理空标题：如果标题为空或"（无标题）"，统一使用"新任务"
            const normalizedCardTitle = cardToDelete.title && cardToDelete.title.trim() && cardToDelete.title !== '（无标题）' 
              ? cardToDelete.title.trim() 
              : '新任务'
            
            // 如果任务卡片有taskListId，从对应的任务列表删除
            if (cardToDelete.taskListId) {
              const targetTaskList = taskListStore.taskLists.find(list => list.id === cardToDelete.taskListId)
              if (targetTaskList) {
                // 查找并删除匹配的任务
                const taskToDelete = targetTaskList.tasks.find(task => {
                  const normalizedTaskTitle = task.title && task.title.trim() ? task.title.trim() : '新任务'
                  return task.date === taskDate && normalizedTaskTitle === normalizedCardTitle
                })
                if (taskToDelete) {
                  console.log('从日历同步删除任务列表中的任务:', taskToDelete.id, normalizedCardTitle, '列表:', targetTaskList.name)
                  await taskListStore.deleteTask(targetTaskList.id, taskToDelete.id, true) // 跳过日历同步
                } else {
                  console.warn('未找到要删除的任务列表任务:', normalizedCardTitle, taskDate, '列表:', targetTaskList.name)
                }
              } else {
                console.warn('未找到对应的任务列表:', cardToDelete.taskListId)
              }
            } else {
              // 兼容旧数据：如果没有taskListId，从"我的任务"列表删除
              const myTaskList = taskListStore.taskLists.find(list => list.name === '我的任务')
              if (myTaskList) {
                // 查找并删除匹配的任务（通过日期和标题匹配）
                const taskToDelete = myTaskList.tasks.find(task => {
                  const normalizedTaskTitle = task.title && task.title.trim() ? task.title.trim() : '新任务'
                  return task.date === taskDate && normalizedTaskTitle === normalizedCardTitle
                })
                if (taskToDelete) {
                  console.log('从日历同步删除任务列表中的任务:', taskToDelete.id, normalizedCardTitle)
                  await taskListStore.deleteTask(myTaskList.id, taskToDelete.id, true) // 跳过日历同步
                } else {
                  console.warn('未找到要删除的任务列表任务:', normalizedCardTitle, taskDate)
                }
              } else {
                console.warn('未找到"我的任务"列表，无法同步删除')
              }
            }
          } catch (syncError) {
            console.error('同步删除任务列表中的任务失败:', syncError)
            // 不同步失败不影响主流程
          } finally {
            isSyncingToTaskList.value = false
          }
        }
      }
    } catch (error) {
      console.error('删除任务卡片失败:', error)
      throw error
    }
  }

  // 初始化卡片数据
  const initializeCards = async () => {
    try {
      const [activityData, missionData] = await Promise.all([
        activityCardApi.getAll(),
        missionCardApi.getAll()
      ])
      activityCards.value = activityData
      missionCards.value = missionData
      
      // 同步任务列表中的任务到日历
      await syncTasksFromTaskListToCalendar()
    } catch (error) {
      console.error('初始化卡片数据失败:', error)
    }
  }

  // 从任务列表同步任务到日历（用于应用启动时）
  const syncTasksFromTaskListToCalendar = async () => {
    try {
      const taskListStore = useTaskListStore()
      
      // 确保任务列表已初始化
      if (taskListStore.taskLists.length === 0) {
        await taskListStore.init()
      }
      
      // 遍历所有任务列表
      for (const taskList of taskListStore.taskLists) {
        if (!taskList.tasks || taskList.tasks.length === 0) {
          continue // 跳过没有任务的任务列表
        }
      
      // 格式化日期为字符串（用于比较）
      const formatDateForCalendar = (date: Date): string => {
        const year = date.getFullYear()
        const month = String(date.getMonth() + 1).padStart(2, '0')
        const day = String(date.getDate()).padStart(2, '0')
        return `${year}-${month}-${day}`
      }
      
      // 解析任务日期为Date对象
      const parseTaskDate = (date: string | 'today' | 'tomorrow'): Date => {
        const today = new Date()
        today.setHours(0, 0, 0, 0)
        
        if (date === 'today') {
          return new Date(today)
        } else if (date === 'tomorrow') {
          const tomorrow = new Date(today)
          tomorrow.setDate(tomorrow.getDate() + 1)
          return tomorrow
        } else {
          // 解析日期字符串 YYYY-MM-DD
          const parts = date.split('-')
          if (parts.length === 3) {
            const year = parseInt(parts[0], 10)
            const month = parseInt(parts[1], 10) - 1 // 月份从0开始
            const day = parseInt(parts[2], 10)
            return new Date(year, month, day)
          }
          return new Date(today) // 默认返回今天
        }
      }
      
        // 遍历任务列表中的每个任务
        for (const task of taskList.tasks) {
          // 统一处理空标题：如果标题为空，统一使用"新任务"
          const normalizedTaskTitle = task.title && task.title.trim() ? task.title.trim() : '新任务'
          
          // 将任务日期转换为Date对象
          const taskDateStr = task.date || 'today'
          const taskDate = parseTaskDate(taskDateStr)
          const taskDateFormatted = formatDateForCalendar(taskDate)
          
          // 检查日历中是否已存在对应的任务卡片
          // 优先通过taskListId匹配，如果没有taskListId则通过日期和标题匹配
          const existingCard = missionCards.value.find(card => {
            if (card.taskListId) {
              // 如果有taskListId，优先通过taskListId匹配
              return card.taskListId === taskList.id && card.title === normalizedTaskTitle
            } else {
              // 否则通过日期和标题匹配（兼容旧数据）
              const cardDateStr = formatDateForCalendar(card.date)
              const normalizedCardTitle = card.title && card.title.trim() && card.title !== '（无标题）' 
                ? card.title.trim() 
                : '新任务'
              return cardDateStr === taskDateFormatted && normalizedCardTitle === normalizedTaskTitle
            }
          })
          
          if (!existingCard) {
            // 如果日历中不存在对应的任务卡片，创建新的任务卡片
            console.log('从任务列表同步任务到日历:', normalizedTaskTitle, taskDateFormatted, '列表:', taskList.name)
            const missionCardData: Omit<missionCard, 'id' | 'createdAt' | 'updatedAt'> = {
              type: 'task',
              date: taskDate,
              title: normalizedTaskTitle,
              missionDate: taskDate,
              remark: task.description || '',
              isFinished: task.completed || false,
              originContext: 'allDay', // 从任务列表添加的任务默认是全天事件
              taskListId: taskList.id // 关联的任务列表ID
            }
            
            await saveMCard({
              ...missionCardData,
              id: '', // 会在saveMCard中生成
              createdAt: new Date(),
              updatedAt: new Date()
            } as missionCard, true) // skipTaskListSync = true，避免循环同步
          } else {
            // 如果已存在，更新任务卡片的状态（确保完成状态等同步）
            const needsUpdate = existingCard.isFinished !== task.completed || 
                               existingCard.remark !== (task.description || '') ||
                               existingCard.taskListId !== taskList.id
            
            if (needsUpdate) {
              console.log('更新日历中的任务卡片状态:', existingCard.id, normalizedTaskTitle)
              await saveMCard({
                ...existingCard,
                isFinished: task.completed,
                remark: task.description || '',
                taskListId: taskList.id, // 确保taskListId正确
                updatedAt: new Date()
              } as missionCard, true) // skipTaskListSync = true
            }
          }
        }
      }
    } catch (error) {
      console.error('从任务列表同步任务到日历失败:', error)
      // 不同步失败不影响主流程
    }
  }

  // 检查日期是否有卡片
  const hasCardForDate = (date: Date) => {
    const dateString = date.toDateString()
    
    const hasActivity = activityCards.value.some(card => 
      card.date.toDateString() === dateString
    )
    
    const hasMission = missionCards.value.some(card => 
      card.date.toDateString() === dateString
    )
    
    return hasActivity || hasMission || (tempButtonDate.value && tempButtonDate.value.toDateString() === dateString)
  }

  // 获取卡片标题
  const getCardTitleForDate = (date: Date) => {
    const dateString = date.toDateString()
    
    // 如果是临时按钮，优先显示临时标题（不管是否有已保存的卡片）
    if (tempButtonDate.value && tempButtonDate.value.toDateString() === dateString) {
      return tempCardTitle.value || '新卡片'
    }
    
    // 统计该日期的卡片数量
    const activityCardsForDate = activityCards.value.filter(card => 
      card.date.toDateString() === dateString || 
      (card.startDate && new Date(card.startDate).toDateString() === dateString)
    )
    const missionCardsForDate = missionCards.value.filter(card => 
      card.date.toDateString() === dateString
    )
    const totalCards = activityCardsForDate.length + missionCardsForDate.length
    
    // 如果有多个卡片，显示第一个卡片的标题和数量
    if (totalCards > 1) {
      const firstCard = activityCardsForDate[0] || missionCardsForDate[0]
      if (firstCard) {
        return `${firstCard.title || '(无标题)'} (共${totalCards}个)`
      }
    }
    
    // 如果只有一个卡片，显示标题
    const activityCard = activityCardsForDate[0]
    if (activityCard) return activityCard.title || '(无标题)'
    
    const missionCard = missionCardsForDate[0]
    if (missionCard) return missionCard.title || '(无标题)'
    
    return ''
  }

  // 获取特定日期的卡片（返回第一个找到的）
  const getCardForDate = (date: Date): activityCard | missionCard | null => {
    const dateString = date.toDateString()
    
    // 查找活动卡片（可能使用 startDate 或 date）
    const activityCard = activityCards.value.find(card => 
      card.date.toDateString() === dateString || 
      (card.startDate && new Date(card.startDate).toDateString() === dateString)
    )
    if (activityCard) return activityCard
    
    // 查找任务卡片
    const missionCard = missionCards.value.find(card => 
      card.date.toDateString() === dateString
    )
    if (missionCard) return missionCard
    
    return null
  }

  // 获取特定日期的活动卡片
  const getActivityCardsForDate = (date: Date) => {
    const dateString = date.toDateString()
    return activityCards.value.filter(card => 
      card.date.toDateString() === dateString
    )
  }

  // 获取特定日期的任务卡片
  const getMissionCardsForDate = (date: Date) => {
    const dateString = date.toDateString()
    return missionCards.value.filter(card => 
      card.date.toDateString() === dateString
    )
  }

  // 日历显示状态管理
  const showActivityCards = ref(true) // 是否显示活动卡片
  const visibleTaskListIds = ref<Set<string>>(new Set()) // 可见的任务列表ID集合

  // 设置活动卡片显示状态
  const setShowActivityCards = (show: boolean) => {
    showActivityCards.value = show
  }

  // 设置任务列表显示状态
  const setTaskListVisible = (listId: string, visible: boolean) => {
    if (visible) {
      visibleTaskListIds.value.add(listId)
    } else {
      visibleTaskListIds.value.delete(listId)
    }
  }

  // 检查任务列表是否可见
  const isTaskListVisible = (listId: string) => {
    return visibleTaskListIds.value.has(listId)
  }

  // 初始化任务列表显示状态（默认显示"我的任务"）
  const initTaskListVisibility = async () => {
    const taskListStore = useTaskListStore()
    if (taskListStore.taskLists.length === 0) {
      await taskListStore.init()
    }
    // 默认显示"我的任务"列表
    const myTaskList = taskListStore.taskLists.find(list => list.name === '我的任务')
    if (myTaskList) {
      visibleTaskListIds.value.add(myTaskList.id)
    }
  }

  // 检查任务卡片是否应该显示（根据任务列表可见性）
  const shouldShowMissionCard = (card: missionCard) => {
    // 如果所有任务列表都不可见，不显示任何任务卡片
    if (visibleTaskListIds.value.size === 0) {
      return false
    }
    
    // 如果任务卡片有taskListId，直接检查该任务列表是否可见
    if (card.taskListId) {
      return visibleTaskListIds.value.has(card.taskListId)
    }
    
    // 兼容旧数据：如果没有taskListId，检查"我的任务"列表是否可见
    const taskListStore = useTaskListStore()
    const myTaskList = taskListStore.taskLists.find(list => list.name === '我的任务')
    if (myTaskList && visibleTaskListIds.value.has(myTaskList.id)) {
      return true
    }
    
    return false
  }

  return {
    showBaseCard,
    baseCardPosition,
    currentSelectedDate,
    activityCards,
    missionCards,
    tempButtonDate,
    tempCardTitle,
    updateTempCardTitle,
    updateTempButtonDate,
    showDetailCard,
    currentDetailCard,
    detailCardPosition,
    openBaseCard,
    closeBaseCard,
    openDetailCard,
    closeDetailCard,
    updateBaseCardPosition,
    adjustedBaseCardPosition,
    adjustedDetailCardPosition,
    saveACard,
    saveMCard,
    hasCardForDate,
    getCardTitleForDate,
    getCardForDate,
    getActivityCardsForDate,
    getMissionCardsForDate,
    deleteACard,
    deleteMCard,
    initializeCards,
    showActivityCards,
    visibleTaskListIds,
    setShowActivityCards,
    setTaskListVisible,
    isTaskListVisible,
    initTaskListVisibility,
    shouldShowMissionCard
  }
})